// 全局请求头管理模块
function initGlobalHeadersFunctions(app) {
    // 扩展HttpRequestTool类，添加全局请求头相关方法
    Object.assign(app, {
        // 加载全局请求头
        async loadGlobalHeaders() {
            try {
                // 从设置中加载全局请求头
                if (this.settings.globalHeaders && Array.isArray(this.settings.globalHeaders)) {
                    return this.settings.globalHeaders;
                }
            } catch (error) {
                console.error('加载全局请求头失败:', error);
            }
            return [];
        },

        // 保存全局请求头
        async saveGlobalHeaders(headers) {
            try {
                this.settings.globalHeaders = headers;
                await this.saveSettings();
                return true;
            } catch (error) {
                console.error('保存全局请求头失败:', error);
                return false;
            }
        },

        // 应用全局请求头到标签页请求头（全局请求头优先级低于标签页请求头）
        applyGlobalHeaders(tabHeaders) {
            // 如果没有全局请求头，直接返回标签页请求头
            if (!this.settings.globalHeaders || !Array.isArray(this.settings.globalHeaders)) {
                return tabHeaders;
            }

            // 创建标签页请求头的Map，用于快速查找
            const tabHeadersMap = new Map();
            for (const key in tabHeaders) {
                tabHeadersMap.set(key.toLowerCase(), { key, value: tabHeaders[key] });
            }

            // 合并全局请求头，仅添加标签页中不存在的请求头
            const mergedHeaders = { ...tabHeaders };
            this.settings.globalHeaders.forEach(header => {
                const keyLower = header.key.toLowerCase();
                if (!tabHeadersMap.has(keyLower)) {
                    mergedHeaders[header.key] = header.value;
                }
            });

            return mergedHeaders;
        }
    });
}

// 全局函数定义
async function renderGlobalHeadersPanel() {
    const container = document.getElementById('global-headers-container');
    if (!container) return;

    try {
        // 加载全局请求头
        const globalHeaders = app.settings.globalHeaders || [];
        
        // 清空容器
        container.innerHTML = '';
        
        // 渲染请求头表格
        const table = document.createElement('div');
        table.className = 'headers-table';
        
        // 表头
        const headerRow = document.createElement('div');
        headerRow.className = 'table-header';
        headerRow.innerHTML = `
            <div class="col-key">键</div>
            <div class="col-value">值</div>
            <div class="col-action">操作</div>
        `;
        table.appendChild(headerRow);
        
        // 表格主体
        const body = document.createElement('div');
        body.className = 'table-body';
        body.id = 'global-headers-list';
        
        // 添加已有的全局请求头
        if (globalHeaders.length === 0) {
            // 如果没有请求头，添加一个空行
            addGlobalHeaderRow(body);
        } else {
            globalHeaders.forEach(header => {
                addGlobalHeaderRow(body, header.key, header.value);
            });
        }
        
        table.appendChild(body);
        
        // 添加按钮
        const addButton = document.createElement('button');
        addButton.className = 'btn btn-small';
        addButton.id = 'add-global-header';
        addButton.textContent = '+ 添加请求头';
        addButton.addEventListener('click', () => {
            addGlobalHeaderRow(document.getElementById('global-headers-list'));
            // 添加新行后自动保存
            setTimeout(async () => {
                await saveGlobalHeadersFromUI();
            }, 0);
        });
        
        container.appendChild(table);
        container.appendChild(addButton);
        
    } catch (error) {
        console.error('渲染全局请求头面板失败:', error);
        container.innerHTML = '<div class="error-message">加载全局请求头失败</div>';
    }
}

// 添加全局请求头行
function addGlobalHeaderRow(container, key = '', value = '') {
    const row = document.createElement('div');
    row.className = 'header-row';
    row.innerHTML = `
        <input type="text" class="header-key" placeholder="键名" value="${key}">
        <input type="text" class="header-value" placeholder="值" value="${value}">
        <button class="btn-remove">删除</button>
    `;
    
    // 获取input元素
    const keyInput = row.querySelector('.header-key');
    const valueInput = row.querySelector('.header-value');
    
    // 添加input事件监听，实现自动保存
    const handleInput = debounce(async () => {
        await saveGlobalHeadersFromUI();
    }, 500); // 500毫秒防抖
    
    keyInput.addEventListener('input', handleInput);
    valueInput.addEventListener('input', handleInput);
    
    // 删除按钮事件
    const removeBtn = row.querySelector('.btn-remove');
    removeBtn.addEventListener('click', async () => {
        container.removeChild(row);
        // 如果删除后没有行了，添加一个新行
        if (container.children.length === 0) {
            addGlobalHeaderRow(container);
        }
        // 删除后自动保存
        await saveGlobalHeadersFromUI();
    });
    
    container.appendChild(row);
}

// 防抖函数
function debounce(func, wait) {
    let timeout;
    return function() {
        const context = this;
        const args = arguments;
        clearTimeout(timeout);
        timeout = setTimeout(() => func.apply(context, args), wait);
    };
}

// 从UI保存全局请求头
async function saveGlobalHeadersFromUI() {
    const rows = document.querySelectorAll('#global-headers-list .header-row');
    const headers = [];
    
    rows.forEach(row => {
        const key = row.querySelector('.header-key').value.trim();
        const value = row.querySelector('.header-value').value.trim();
        
        if (key) {
            headers.push({ key, value });
        }
    });
    
    await app.saveGlobalHeaders(headers);
}

// 导出函数以便在其他文件中使用
window.initGlobalHeadersFunctions = initGlobalHeadersFunctions;
window.renderGlobalHeadersPanel = renderGlobalHeadersPanel;
window.saveGlobalHeadersFromUI = saveGlobalHeadersFromUI;